package com.sdp.th.cwt;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.HashMap;
import java.util.Map;

import com.alibaba.fastjson.JSONObject;
import com.sdp.th.utils.HexStringUtils;

public class ISNBParser {
	
	private static String alarmMessageId = "02"; //报警
	private static String faultMessageId = "05"; //故障
	private static String heartMessageId = "01";//心跳
	private static String alarmEventType = "0064";
	private static String faultEventType = "0063";//故障类型
	private static String newFixedSign = "01";
	private static String paramTypePower = "0015";//电量参数类型

	/**
	 * 获取烟感设备状态
	 * 
	 * @param data
	 * @return
	 */
	public static JSONObject smokeState(String data) {
		JSONObject stateObj = new JSONObject();
		stateObj.put("smokeAlarm", false);
		stateObj.put("powerAlarm", false);
		stateObj.put("devicePower", null);//设备电量

		String messageId = data.substring(0, 2);
		String fixedSign = data.substring(2, 4);
		if (!newFixedSign.equals(fixedSign)) {
			return stateObj;
		}

		// 包头的长度
		int headLength = Integer.parseInt(HexStringUtils.hexToDecimal(data.substring(40, 48)));

		// 多通道消息头长度
		int multiHeadLength = 10;

		// 通道类型
		String chanType = data.substring(392, 396);

		// 通道数
		int chanNum = Integer.parseInt(HexStringUtils.hexToDecimal(data.substring(396, 400)));

		// 每个通道长度，14个字节，16进制乘以2
		int chanDataLen = 14 * 2;

		// 开始解析多通道数
		int bodySt = (headLength + multiHeadLength) * 2;
		int bodyEt = bodySt + (chanDataLen * chanNum);
		String body = data.substring(bodySt, bodyEt);

		// 循环解析
		for (int i = 0; i < chanNum * chanDataLen; i = i + chanDataLen) {
			String eventType = body.substring(i + 8, i + 12);
			String eventValueHight = body.substring(i + 12, i + 16);
			String eventValue = body.substring(i + 16, i + 20);// 事件低16位
			String paramType = body.substring(i + 20, i + 24);
			String paramVal = body.substring(i + 24, i + 28);
			
//			System.out.println(paramType);
//			System.out.println(paramVal);
			
			//心跳
			if(heartMessageId.equals(messageId)) {
				//查看是否有电量信息
				if(faultEventType.equals(eventType) && paramTypePower.equals(paramType)) {
					stateObj.put("devicePower", HexStringUtils.hexToDecimal(paramVal));
				}
				
			}else if (alarmMessageId.equals(messageId)) {
				// 判断是否为报警 字节的位是从右到左编号的
				if(alarmEventType.equals(eventType)) {
					if(isSmokeAlarm(eventValue)) {
						stateObj.put("smokeAlarm", true);
					}
				}
		
			}
			
			/*
			else if(faultMessageId.equals(messageId)) {
				//是否故障
				if(faultEventType.equals(eventType)) {
					if(isPowerAlarm(eventValue)) {//低电压
						stateObj.put("powerAlarm", true);
						if(paramTypePower.equals(paramType)) {
							stateObj.put("devicePower", HexStringUtils.hexToDecimal("paramVal"));
						}
					}
				}
			}
			*/
			
			

		}

//		System.out.println(stateObj);
		return stateObj;
	}

	/**
	 * 判断是否烟感报警
	 * 
	 * @param eventValue
	 * @return
	 */
	public static boolean isSmokeAlarm(String eventValue) {
		String binaryEventValue = HexStringUtils.hexToBinary(eventValue, 2);
		return HexStringUtils.getBitValue(binaryEventValue, 0) == 1;
	}

	
	/**
	 * 是否低电量报警
	 * @param eventValue
	 * @return
	 */
	public static boolean isPowerAlarm(String eventValue) {
		String binaryEventValue = HexStringUtils.hexToBinary(eventValue, 2);
		return HexStringUtils.getBitValue(binaryEventValue, 3) == 1;
	}
	
	
	
	/**
	 * 下面是久的代码
	 */

	// 头部解析（包含扩展字段）
	public static Map<String, Object> parseUpHeader(ByteBuffer buffer) {
		Map<String, Object> header = new HashMap<>();
		header.put("byMessageId", buffer.get() & 0xFF); // 业务类型
		header.put("byFixedSign", buffer.get() & 0xFF); // 扩展标志位
		header.put("byDevType", buffer.get() & 0xFF); // 设备类型低位
		byte[] mac = new byte[6];
		buffer.get(mac);
		header.put("byMac", bytesToHex(mac)); // MAC地址

		// 时间戳（小端序）
		byte[] timeBytes = new byte[4];
		buffer.get(timeBytes);
		header.put("byTime", ByteBuffer.wrap(timeBytes).order(ByteOrder.LITTLE_ENDIAN).getInt());

		// 设备类型高位
		header.put("byDevTypeEx", buffer.get() & 0xFF);

		// 小区编号
		header.put("wPCI", buffer.getShort() & 0xFFFF); // 无符号short

		// 网络质量
		header.put("bySnr", buffer.get() & 0xFF);
		header.put("byEcl", buffer.get() & 0xFF);
		header.put("wRsrp", buffer.getShort() & 0xFF);

		// 处理扩展头（dwUpHeaderLen>0）
		if ((Integer) header.get("byFixedSign") == 0x01) {
			// 从字节流中读取4个字节
			int upHeaderLen = buffer.getInt();
			if (upHeaderLen > 0) {
				header.put("dwUpHeaderLen", upHeaderLen);
				// 包序号（DWPackageNo）
				header.put("dwPackageNo", buffer.getInt());
				header.put("byQCCID", parseString(buffer, 20));
				header.put("byIMEI", parseString(buffer, 20));
				header.put("byIMSI", parseString(buffer, 20));
				header.put("nbversion", parseString(buffer, 24));
			}

			// header.put("dwCID", buffer.getInt());
			// header.put("dwLAC", buffer.getInt());
			// header.put("softVersion", parseString(buffer, 20));
			// header.put("hardWareVersion", parseString(buffer, 20));
			// header.put("deviceModel", parseString(buffer, 20));
			// header.put("protocolversion", parseString(buffer, 10));
		}

		return header;
	}

	// 报警判断逻辑
	public static boolean isSmokeAlarm(byte[] data) {
		ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.BIG_ENDIAN);

		int messageId = buffer.get() & 0xFF;
		if (messageId != 0x02)
			return false;

		buffer.position(0);

		Map<String, Object> header = parseUpHeader(buffer);

		int headerLength = Integer.parseInt(header.get("dwUpHeaderLen").toString());

		// 跳过header
		buffer.position(headerLength);

		// 多通道结构

		buffer.get();
		int byMsgType = buffer.get() & 0xFF;
		if (byMsgType != 1)
			return false;
		// int byShield = buffer.get() & 0xFF;
		// int muversion = buffer.get() & 0xFF;
		//
		// int wLen = buffer.getShort() & 0xFF;
		// int rscType = buffer.getShort() & 0xFF;
		// int rscValue = buffer.getShort() & 0xFF;

		// 直接读取8个字节（跳过）
		buffer.getLong();
		// buffer.position(headerLength+10);

		int wType = buffer.getShort() & 0xFF;
		// System.out.println(Integer.toHexString(wType));
		int wValue = buffer.getShort() & 0xFF;
		// System.out.println(Integer.toHexString(wValue));

		int wEventType = buffer.getShort() & 0xFF;
		// System.out.println(Integer.toHexString(wEventType));
		if (wEventType != 0x64)
			return false;

		// 跳过事件值高位
		buffer.getShort();

		short wEventValue = buffer.getShort();
		// System.out.println(wEventValue);
		return (wEventValue & 0x0001) != 0;

		/**
		 * 
		 * // 2. 解析多通道头（MULTI_CHAN_HEADER） buffer.get(); // 跳过byRes（保留字节） int byMsgType
		 * = buffer.get() & 0xFF; // 消息类型 if (byMsgType != 1) return false; // 非报警类型消息
		 * 
		 * // 3. 解析通道体（MULTI_CHAN_BODY） short wType = buffer.getShort(); // 通道类型 short
		 * wValue = buffer.getShort(); // 通道值（当wType=0x61时）
		 * 
		 * // 事件类型校验（必须为0x64报警类型） short wEventType = buffer.getShort(); if (wEventType
		 * != 0x64) return false;
		 * 
		 * // 获取事件的两个16位值（注意文档中事件值的存储顺序） short wEventValueLow = buffer.getShort(); //
		 * ...跳过其他参数（wParamType等）
		 * 
		 * // BitMask操作：检查第一个bit（烟雾报警位） return (wEventValueLow & 0x0001) != 0;
		 */
	}

	// 设备ID提取
	public static String getDeviceId(byte[] data) {
		ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.BIG_ENDIAN);
		Map<String, Object> header = parseUpHeader(buffer);
		return (String) header.get("byIMEI");

	}

	// 工具函数
	private static String bytesToHex(byte[] bytes) {
		StringBuilder sb = new StringBuilder();
		for (byte b : bytes)
			sb.append(String.format("%02X", b));
		return sb.toString();
	}

	private static String parseString(ByteBuffer buffer, int length) {
		byte[] bytes = new byte[length];
		buffer.get(bytes);
		return new String(bytes).trim();
	}
}
